home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / peak / util / addons.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  5.7 KB  |  202 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from peak.util.decorators import decorate_class, enclosing_frame, classy
  5. from weakref import ref
  6. import sys
  7. __all__ = [
  8.     'AddOn',
  9.     'ClassAddOn',
  10.     'Registry',
  11.     'addons_for']
  12. _addons = { }
  13.  
  14. def addons_for(ob):
  15.     
  16.     try:
  17.         d = ob.__dict__
  18.         sd = d.setdefault
  19.         return d
  20.     except (AttributeError, TypeError):
  21.         r = ref(ob)
  22.         
  23.         try:
  24.             return _addons[r]
  25.         except KeyError:
  26.             return _addons.setdefault(ref(ob, _addons.__delitem__), { })
  27.         except:
  28.             None<EXCEPTION MATCH>KeyError
  29.         
  30.  
  31.         None<EXCEPTION MATCH>KeyError
  32.  
  33.  
  34.  
  35. def additional_tests():
  36.     import doctest
  37.     return doctest.DocFileSuite('README.txt', package = '__main__', optionflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
  38.  
  39.  
  40. class AddOn(classy):
  41.     __slots__ = ()
  42.     
  43.     def __class_call__(cls, ob, *data):
  44.         a = addons_for(ob)
  45.         addon_key = cls.addon_key(*data)
  46.         
  47.         try:
  48.             return a[addon_key]
  49.         except KeyError:
  50.             ob = a.setdefault(addon_key, super(AddOn, cls).__class_call__(ob, *data))
  51.             return ob
  52.  
  53.  
  54.     __class_call__ = classmethod(__class_call__)
  55.     
  56.     def addon_key(cls, *args):
  57.         if args:
  58.             return (cls,) + args
  59.         
  60.         return cls
  61.  
  62.     addon_key = classmethod(addon_key)
  63.     
  64.     def exists_for(cls, ob, *key):
  65.         return cls.addon_key(*key) in addons_for(ob)
  66.  
  67.     exists_for = classmethod(exists_for)
  68.     
  69.     def delete_from(cls, ob, *key):
  70.         a = addons_for(ob)
  71.         
  72.         try:
  73.             del a[cls.addon_key(*key)]
  74.         except KeyError:
  75.             pass
  76.  
  77.  
  78.     delete_from = classmethod(delete_from)
  79.     
  80.     def __init__(self, subject):
  81.         pass
  82.  
  83.  
  84.  
  85. class ClassAddOn(AddOn):
  86.     __slots__ = ()
  87.     
  88.     def __class_call__(cls, ob, *data):
  89.         addon_key = cls.addon_key(*data)
  90.         d = ob.__dict__
  91.         if addon_key in d:
  92.             return d[addon_key]
  93.         
  94.         d2 = addons_for(ob)
  95.         
  96.         try:
  97.             return d2[addon_key]
  98.         except KeyError:
  99.             ob = d2.setdefault(addon_key, super(ClassAddOn, cls).__class_call__(ob, *data))
  100.             return ob
  101.  
  102.  
  103.     __class_call__ = classmethod(__class_call__)
  104.     
  105.     def for_enclosing_class(cls, *args, **kw):
  106.         if 'frame' in kw:
  107.             frame = kw.pop('frame')
  108.         elif 'level' in kw:
  109.             level = kw.pop('level')
  110.         else:
  111.             level = 2
  112.         frame = sys._getframe(level)
  113.         if kw:
  114.             raise TypeError('Unexpected keyword arguments', kw)
  115.         
  116.         return cls.for_frame(frame, *args)
  117.  
  118.     for_enclosing_class = classmethod(for_enclosing_class)
  119.     
  120.     def for_frame(cls, frame, *args):
  121.         a = enclosing_frame(frame).f_locals
  122.         addon_key = cls.addon_key(*args)
  123.         
  124.         try:
  125.             return a[addon_key]
  126.         except KeyError:
  127.             ob = a.setdefault(addon_key, type.__call__(cls, None, *args))
  128.             (decorate_class,)((lambda c: ob._ClassAddOn__decorate(c)), frame = frame)
  129.             return ob
  130.  
  131.  
  132.     for_frame = classmethod(for_frame)
  133.     
  134.     def exists_for(cls, ob, *key):
  135.         addon_key = cls.addon_key(*key)
  136.         if not addon_key in ob.__dict__:
  137.             pass
  138.         return addon_key in addons_for(ob)
  139.  
  140.     exists_for = classmethod(exists_for)
  141.     
  142.     def delete_from(cls, ob, *key):
  143.         raise TypeError('ClassAddOns cannot be deleted')
  144.  
  145.     delete_from = classmethod(delete_from)
  146.     
  147.     def __decorate(self, cls):
  148.         self.created_for(cls)
  149.         return cls
  150.  
  151.     
  152.     def created_for(self, cls):
  153.         pass
  154.  
  155.     
  156.     def __init__(self, subject):
  157.         if subject is not None:
  158.             self.created_for(subject)
  159.         
  160.  
  161.  
  162.  
  163. class Registry(ClassAddOn, dict):
  164.     __slots__ = ()
  165.     
  166.     def __new__(cls, subject):
  167.         if cls is Registry:
  168.             raise TypeError('You must subclass Registry to use it')
  169.         
  170.         return super(Registry, cls).__new__(cls)
  171.  
  172.     
  173.     def __init__(self, subject):
  174.         dict.__init__(self)
  175.         super(Registry, self).__init__(subject)
  176.  
  177.     
  178.     def created_for(self, cls):
  179.         
  180.         try:
  181.             mro = cls.__mro__[::-1]
  182.         except AttributeError:
  183.             mro = type(cls.__name__, (cls, object), { }).__mro__[1:][::-1]
  184.  
  185.         data = { }
  186.         self.defined_in_class = dict(self)
  187.         mytype = type(self)
  188.         for base in mro[:-1]:
  189.             data.update(mytype(base))
  190.         
  191.         data.update(self)
  192.         self.update(data)
  193.  
  194.     
  195.     def set(self, key, value):
  196.         if key in self and self[key] != value:
  197.             raise ValueError("%s[%r] already contains %r; can't set to %r" % (self.__class__.__name__, key, self[key], value))
  198.         
  199.         self[key] = value
  200.  
  201.  
  202.